Page({
  data: {
    statusBarHeight: 0,
    latitude: null, // 🔥 不使用默认位置，必须真实定位
    longitude: null, // 🔥 不使用默认位置，必须真实定位
    markers: [],
    address: '',
    searchKeyword: '',
    searchResults: [],
    showSearchResults: false,
    scale: 16,
    aMapKey: 'b2dec638f9508c079a4da1c7262ca67a',
    isMoving: false,  // 🔥 标记地图是否正在移动
    isLocationReady: false  // 🔥 标记位置是否已准备好
  },

  // 防抖定时器
  debounceTimer: null,
  // 搜索输入防抖定时器
  searchInputTimer: null,
  // 上次获取地址的位置
  lastAddressLocation: null,
  // 🔥 是否正在主动重新定位（避免被 onRegionChange 干扰）
  isRelocating: false,
  // 🔥 是否正在选择搜索结果（避免被 onRegionChange 干扰）
  isSelectingSearchResult: false,

  onLoad(options) {
    console.log('🗺️ =============== 地图页面加载 ===============');
    console.log('📊 接收的参数:', options);
    
    // 获取系统状态栏高度
    const systemInfo = wx.getSystemInfoSync();
    this.setData({
      statusBarHeight: systemInfo.statusBarHeight
    });
    
    // 如果有传入的位置信息，使用传入的
    if (options.location && options.latitude && options.longitude) {
      const lat = parseFloat(options.latitude);
      const lng = parseFloat(options.longitude);
      
      console.log('📍 使用传入的位置:', {
        location: options.location,
        latitude: lat,
        longitude: lng
      });
      
      this.setData({
        address: decodeURIComponent(options.location),
        latitude: lat,
        longitude: lng,
        isLocationReady: true  // 🔥 位置已准备好，显示地图
      });
      
      // 🔥 保存中心点坐标
      this.centerLatitude = lat;
      this.centerLongitude = lng;
      
      // 更新上次获取地址的位置（避免立即重新获取地址）
      this.lastAddressLocation = { lat, lng };
    } else {
      // 🔥 如果没有传入位置，先获取当前位置再显示地图
      console.log('📍 未传入位置，获取用户当前位置...');
      this.getLocation();
    }
  },

  onShow() {
    // 🔔 自动初始化通知组件
    const app = getApp();
    app.autoInitNotification();
  },

  onUnload() {
    // 页面卸载时清除定时器
    if (this.debounceTimer) {
      clearTimeout(this.debounceTimer);
    }
    if (this.searchInputTimer) {
      clearTimeout(this.searchInputTimer);
    }
  },

  // 获取当前位置
  getLocation(isRelocate = false) {
    const that = this;
    
    // 🔥 如果是主动重新定位，设置标志位和显示"定位中..."
    if (isRelocate) {
      that.isRelocating = true;
      that.setData({
        address: '定位中...'
      });
    }
    
    wx.getLocation({
      type: 'gcj02',
      success(res) {
        console.log('✅ 获取当前位置成功:', res);
        
        that.setData({
          latitude: res.latitude,
          longitude: res.longitude,
          isLocationReady: true  // 🔥 位置已准备好，显示地图
        });
        
        // 🔥 保存中心点坐标
        that.centerLatitude = res.latitude;
        that.centerLongitude = res.longitude;
        
        // 🔥 强制重新获取地址（清除缓存）
        that.lastAddressLocation = null;
        that.getAddressFromLocation(res.latitude, res.longitude);
        
        // 🔥 延迟重置标志位（等待地图动画完成和地址获取）
        setTimeout(() => {
          that.isRelocating = false;
        }, 1500);
      },
      fail(err) {
        console.error('❌ 获取位置失败:', err);
        
        // 🔥 重置标志位
        that.isRelocating = false;
        
        // 🔥 定位失败，显示失败信息，不使用默认位置
        that.setData({
          address: '定位失败',
          latitude: null,
          longitude: null,
          isLocationReady: false // 🔥 不显示地图
        });
        
        // 提示用户开启定位权限
        wx.showModal({
          title: '获取位置失败',
          content: '需要获取您的位置信息，是否前往设置？',
          confirmText: '去设置',
          cancelText: '取消',
          success(modalRes) {
            if (modalRes.confirm) {
              wx.openSetting({
                success(settingRes) {
                  console.log('📱 用户授权结果:', settingRes);
                  // 🔥 如果用户授权了位置权限，重新获取位置
                  if (settingRes.authSetting['scope.userLocation']) {
                    console.log('✅ 用户已授权位置权限，重新获取位置');
                    that.getLocation(isRelocate);
                  }
                }
              });
            }
          }
        });
      }
    });
  },

  // 根据经纬度获取地址
  getAddressFromLocation(lat, lng) {
    // 检查位置是否有明显变化（距离超过50米才重新获取）
    if (this.lastAddressLocation) {
      const distance = this.getDistance(
        this.lastAddressLocation.lat,
        this.lastAddressLocation.lng,
        lat,
        lng
      );
      if (distance < 50) {
        // 位置变化不大，不重新获取地址
        return;
      }
    }

    // 记录本次请求的位置
    this.lastAddressLocation = { lat, lng };

    const that = this;
    wx.request({
      url: 'https://restapi.amap.com/v3/geocode/regeo',
      data: {
        key: this.data.aMapKey,
        location: `${lng},${lat}`,
        extensions: 'base'
      },
      success(res) {
        console.log('获取地址成功:', res.data);
        if (res.data.status === '1' && res.data.regeocode) {
          const regeocode = res.data.regeocode;
          const addressComponent = regeocode.addressComponent;
          const formattedAddress = regeocode.formatted_address;
          
          // 组合地址：优先使用详细地址
          let address = formattedAddress;
          
          // 如果有POI信息，添加到地址中
          if (regeocode.pois && regeocode.pois.length > 0) {
            const poi = regeocode.pois[0];
            address = poi.name || formattedAddress;
          }
          
          that.setData({ address });
        }
      },
      fail(err) {
        console.error('获取地址失败:', err);
        // 如果API调用失败，使用默认地址
        if (!that.data.address) {
          that.setData({ 
            address: '请选择位置'
          });
        }
      }
    });
  },

  // 计算两点间距离（单位：米）
  getDistance(lat1, lng1, lat2, lng2) {
    const radLat1 = lat1 * Math.PI / 180.0;
    const radLat2 = lat2 * Math.PI / 180.0;
    const a = radLat1 - radLat2;
    const b = lng1 * Math.PI / 180.0 - lng2 * Math.PI / 180.0;
    let s = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a / 2), 2) +
      Math.cos(radLat1) * Math.cos(radLat2) * Math.pow(Math.sin(b / 2), 2)));
    s = s * 6378137.0; // 地球半径
    s = Math.round(s * 10000) / 10000;
    return s;
  },

  // 地图区域改变（添加防抖）
  onRegionChange(e) {
    // 🔥 如果正在主动重新定位或选择搜索结果，忽略地图区域变化事件
    if (this.isRelocating) {
      console.log('🚫 正在主动定位，忽略地图区域变化');
      return;
    }
    
    if (this.isSelectingSearchResult) {
      console.log('🚫 正在选择搜索结果，忽略地图区域变化');
      return;
    }
    
    if (e.type === 'begin') {
      // 🔥 开始拖动地图，显示移动状态
      console.log('🗺️ 开始拖动地图');
      this.setData({
        isMoving: true,
        address: '定位中...'
      });
    } else if (e.type === 'end') {
      // 🔥 地图拖动结束
      console.log('🗺️ 地图拖动结束，准备获取地址');
      
      // 清除之前的定时器
      if (this.debounceTimer) {
        clearTimeout(this.debounceTimer);
      }
      
      // 设置新的定时器，800ms后执行（防抖）
      this.debounceTimer = setTimeout(() => {
        console.log('⏰ 防抖时间到，获取中心点地址');
        
        const mapContext = wx.createMapContext('myMap');
        mapContext.getCenterLocation({
          success: (res) => {
            console.log('📍 获取到地图中心点:', res);
            
            // 🔥 只更新状态，不更新地图的 latitude/longitude（避免触发地图重新定位）
            this.setData({
              isMoving: false
            });
            
            // 🔥 保存中心点坐标（用于确认位置时使用）
            this.centerLatitude = res.latitude;
            this.centerLongitude = res.longitude;
            
            // 获取该位置的地址
            this.getAddressFromLocation(res.latitude, res.longitude);
            
            // 🔥 轻微震动反馈
            wx.vibrateShort({
              type: 'light'
            });
          },
          fail: (err) => {
            console.error('❌ 获取地图中心点失败:', err);
            this.setData({
              isMoving: false,
              address: '获取位置失败'
            });
          }
        });
      }, 800);
    }
  },

  // 搜索输入（带防抖）
  onSearchInput(e) {
    const keyword = e.detail.value;
    this.setData({
      searchKeyword: keyword
    });

    // 如果输入为空，清空搜索结果
    if (!keyword || keyword.trim() === '') {
      this.setData({
        searchResults: [],
        showSearchResults: false
      });
      return;
    }

    // 清除之前的搜索定时器
    if (this.searchInputTimer) {
      clearTimeout(this.searchInputTimer);
    }

    // 设置新的定时器，500ms后执行搜索
    this.searchInputTimer = setTimeout(() => {
      this.searchLocation(keyword);
    }, 500);
  },

  // 搜索位置
  searchLocation(keyword) {
    const searchKeyword = keyword || this.data.searchKeyword;
    
    if (!searchKeyword || searchKeyword.trim() === '') {
      return;
    }

    const that = this;
    
    wx.request({
      url: 'https://restapi.amap.com/v3/place/text',
      data: {
        key: this.data.aMapKey,
        keywords: searchKeyword,
        city: '烟台',
        offset: 10
      },
      success(res) {
        console.log('搜索结果:', res.data);
        
        if (res.data.status === '1' && res.data.pois && res.data.pois.length > 0) {
          const searchResults = res.data.pois.map((poi, index) => ({
            id: index,
            name: poi.name,
            address: poi.address || poi.pname + poi.cityname + poi.adname,
            location: poi.location,
            distance: poi.distance || ''
          }));
          
          that.setData({
            searchResults: searchResults,
            showSearchResults: true
          });
        } else {
          that.setData({
            searchResults: [],
            showSearchResults: false
          });
        }
      },
      fail(err) {
        console.error('搜索失败:', err);
        that.setData({
          searchResults: [],
          showSearchResults: false
        });
      }
    });
  },

  // 选择搜索结果
  selectSearchResult(e) {
    const index = e.currentTarget.dataset.index;
    const result = this.data.searchResults[index];
    
    if (!result) return;

    const location = result.location.split(',');
    const lng = parseFloat(location[0]);
    const lat = parseFloat(location[1]);
    
    console.log('🔍 选择搜索结果:', result.name);
    console.log('📍 目标坐标:', { latitude: lat, longitude: lng });
    
    // 🔥 设置标志位，避免 onRegionChange 干扰
    this.isSelectingSearchResult = true;
    
    // 🔥 保存中心点坐标（在更新地图前保存）
    this.centerLatitude = lat;
    this.centerLongitude = lng;
    
    // 更新上次获取地址的位置（避免重复获取）
    this.lastAddressLocation = { lat, lng };
    
    // 🔥 更新地图位置（这里需要更新，因为是主动跳转）
    this.setData({
      latitude: lat,
      longitude: lng,
      address: result.name,
      searchKeyword: '',
      searchResults: [],
      showSearchResults: false
    });
    
    console.log('✅ 地图正在移动到新位置...');
    
    // 🔥 延迟重置标志位（等待地图动画完成）
    setTimeout(() => {
      this.isSelectingSearchResult = false;
      console.log('✅ 搜索结果选择完成');
    }, 1500);
  },

  // 清空搜索
  clearSearch() {
    this.setData({
      searchKeyword: '',
      searchResults: [],
      showSearchResults: false
    });
  },

  // 重新定位
  relocate() {
    console.log('🔄 点击刷新按钮，重新定位');
    this.getLocation(true);  // 🔥 传入 true 表示是主动重新定位
  },

  // 确认选择
  confirmLocation() {
    let { address } = this.data;
    
    // 🔥 使用保存的中心点坐标（如果没有则使用 data 中的）
    const latitude = this.centerLatitude || this.data.latitude;
    const longitude = this.centerLongitude || this.data.longitude;
    
    // 🔥 如果地址还在加载中，提示用户等待
    if (!address || address === '定位中...' || address === '正在获取位置...') {
      wx.showToast({
        title: '正在获取地址，请稍候',
        icon: 'none',
        duration: 2000
      });
      
      // 🔥 强制立即获取地址
      this.lastAddressLocation = null; // 清除缓存，强制重新获取
      this.getAddressFromLocation(latitude, longitude);
      return;
    }
    
    console.log('✅ 确认选择位置:', {
      address: address,
      latitude: latitude,
      longitude: longitude
    });
    
    const pages = getCurrentPages();
    const prevPage = pages[pages.length - 2];
    
    if (prevPage && prevPage.setData) {
      // 🔥 将位置数据传回上一页（支持 main 页面和其他页面）
      if (prevPage.route === 'pages/main/index') {
        // 如果是 main 页面，使用临时数据方式（因为 main 页面有 onShow）
        prevPage.setData({
          _selectedLocation: {
            address: address,
            latitude: latitude,
            longitude: longitude
          }
        });
        console.log('📍 已设置位置数据到 main 页面');
      } else {
        // 🔥 其他页面设置完整的位置数据（地址+经纬度）
        prevPage.setData({
          location: address,
          latitude: latitude,
          longitude: longitude
        });
        console.log('📍 已设置完整位置数据到上一页:', prevPage.route);
        console.log('   地址:', address);
        console.log('   经度:', longitude);
        console.log('   纬度:', latitude);
      }
      
      wx.showToast({
        title: '位置已选择',
        icon: 'success',
        duration: 1000
      });
      
      setTimeout(() => {
        wx.navigateBack();
      }, 1000);
    } else {
      console.warn('⚠️ 未找到上一页，直接返回');
      wx.navigateBack();
    }
  },

  // 返回
  goBack() {
    wx.navigateBack();
  }
});

